use super::super::method::{Method, MethodType};
use super::super::value::{Value, ValueData};
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

/// 字典类型的实现
pub struct Dict;

impl Dict {
    /// 创建字典值
    pub fn create(items: HashMap<String, Value>) -> Value {
        let mut methods = HashMap::new();

        // 查询方法
        methods.insert(
            "长度".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    Ok(Value::number(items.borrow().len() as f64))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "空否".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    Ok(Value::boolean(items.borrow().is_empty()))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "获取".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), key_value) = (&args[0].data, &args[1]) {
                    let key = Self::value_to_key(key_value)?;
                    if let Some(value) = items.borrow().get(&key) {
                        Ok(value.clone())
                    } else {
                        Err(format!("键不存在: {}", key))
                    }
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        // 查询方法（别名为获取）
        methods.insert(
            "查询".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), key_value) = (&args[0].data, &args[1]) {
                    let key = Self::value_to_key(key_value)?;
                    if let Some(value) = items.borrow().get(&key) {
                        Ok(value.clone())
                    } else {
                        Err(format!("键不存在: {}", key))
                    }
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "取或默认".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), key_value, default_value) =
                    (&args[0].data, &args[1], &args[2])
                {
                    let key = Self::value_to_key(key_value)?;
                    if let Some(value) = items.borrow().get(&key) {
                        Ok(value.clone())
                    } else {
                        Ok(default_value.clone())
                    }
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "包含键".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), key_value) = (&args[0].data, &args[1]) {
                    let key = Self::value_to_key(key_value)?;
                    let contains = items.borrow().contains_key(&key);
                    Ok(Value::boolean(contains))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "包含值".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), value) = (&args[0].data, &args[1]) {
                    let contains = items.borrow().values().any(|v| v == value);
                    Ok(Value::boolean(contains))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "键".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    let keys = items
                        .borrow()
                        .keys()
                        .map(|key| Value::string(key.clone()))
                        .collect();
                    Ok(Value::list(keys))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "值".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    let values = items.borrow().values().cloned().collect();
                    Ok(Value::list(values))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "项".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    let items = items.borrow();
                    let tuples: Vec<Value> = items
                        .iter()
                        .map(|(k, v)| Value::tuple(vec![Value::string(k.clone()), v.clone()]))
                        .collect();
                    Ok(Value::list(tuples))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        // 修改方法
        methods.insert(
            "设置".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), key_value, value) =
                    (&args[0].data, &args[1], &args[2])
                {
                    let key = Self::value_to_key(key_value)?;
                    items.borrow_mut().insert(key, value.clone());
                    Ok(args[0].clone())
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        // 修改方法（别名为设置）
        methods.insert(
            "修改".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), key_value, value) =
                    (&args[0].data, &args[1], &args[2])
                {
                    let key = Self::value_to_key(key_value)?;
                    items.borrow_mut().insert(key, value.clone());
                    Ok(args[0].clone())
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "移除".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), key_value) = (&args[0].data, &args[1]) {
                    let key = Self::value_to_key(key_value)?;
                    if let Some(value) = items.borrow_mut().remove(&key) {
                        Ok(value)
                    } else {
                        Err(format!("键不存在: {}", key))
                    }
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "清空".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    items.borrow_mut().clear();
                    Ok(args[0].clone())
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        // 键列表方法
        methods.insert(
            "键列表".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    let keys: Vec<Value> = items
                        .borrow()
                        .keys()
                        .cloned()
                        .map(|k| Value::string(k))
                        .collect();
                    Ok(Value::list(keys))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        // 值列表方法
        methods.insert(
            "值列表".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    let values: Vec<Value> = items.borrow().values().cloned().collect();
                    Ok(Value::list(values))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "更新".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items1), ValueData::Dict(items2)) =
                    (&args[0].data, &args[1].data)
                {
                    let mut borrowed1 = items1.borrow_mut();
                    let borrowed2 = items2.borrow();
                    for (key, value) in borrowed2.iter() {
                        borrowed1.insert(key.clone(), value.clone());
                    }
                    Ok(args[0].clone())
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "弹出".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), key_value) = (&args[0].data, &args[1]) {
                    let key = Self::value_to_key(key_value)?;
                    if let Some(value) = items.borrow_mut().remove(&key) {
                        Ok(value)
                    } else {
                        Err(format!("键不存在: {}", key))
                    }
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        // 转换方法
        methods.insert(
            "复制".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    let new_items = items.borrow().clone();
                    Ok(Value::dict(new_items))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "深复制".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    // 简单的深复制实现，实际项目中可能需要更复杂的实现
                    let new_items = items.borrow().clone();
                    Ok(Value::dict(new_items))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "合并".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items1), ValueData::Dict(items2)) =
                    (&args[0].data, &args[1].data)
                {
                    let mut new_items = items1.borrow().clone();
                    let borrowed2 = items2.borrow();
                    for (key, value) in borrowed2.iter() {
                        new_items.insert(key.clone(), value.clone());
                    }
                    Ok(Value::dict(new_items))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        // 转换方法
        methods.insert(
            "转换为列表".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    let items = items.borrow();
                    let mut result = Vec::new();
                    for (key, value) in items.iter() {
                        result.push(Value::string(key.clone()));
                        result.push(value.clone());
                    }
                    Ok(Value::list(result))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "转换为元组".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    let items = items.borrow();
                    let mut result = Vec::new();
                    for (key, value) in items.iter() {
                        result.push(Value::string(key.clone()));
                        result.push(value.clone());
                    }
                    Ok(Value::tuple(result))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        methods.insert(
            "转换为键值对".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let ValueData::Dict(items) = &args[0].data {
                    let items = items.borrow();
                    let mut result = Vec::new();
                    for (key, value) in items.iter() {
                        let pair = Value::tuple(vec![Value::string(key.clone()), value.clone()]);
                        result.push(pair);
                    }
                    Ok(Value::list(result))
                } else {
                    Err("不是字典类型".to_string())
                }
            }),
        );

        // 高阶方法
        methods.insert(
            "映射值".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), func_value) = (&args[0].data, &args[1]) {
                    match &func_value.data {
                        ValueData::Function {
                            params,
                            body: _,
                            closure: _,
                            return_type: _,
                        } => {
                            let mut new_items = std::collections::HashMap::new();
                            let items = items.borrow();

                            for (key, value) in items.iter() {
                                // 创建函数调用参数
                                let mut func_args = Vec::new();

                                if params.len() >= 2 {
                                    // 如果有两个参数，键和值都传递
                                    func_args.push(crate::ast::Argument::Positional(
                                        crate::ast::ASTNode::String(key.clone(), None),
                                        None,
                                    ));
                                    // 根据值的类型创建相应的ASTNode
                                    let value_node = match &value.data {
                                        crate::interpreter::value::ValueData::Number(n) => {
                                            if *n == n.floor() {
                                                crate::ast::ASTNode::Integer(*n as i64, None)
                                            } else {
                                                crate::ast::ASTNode::Float(*n, None)
                                            }
                                        }
                                        crate::interpreter::value::ValueData::String(s) => {
                                            crate::ast::ASTNode::String(s.clone(), None)
                                        }
                                        crate::interpreter::value::ValueData::Boolean(b) => {
                                            crate::ast::ASTNode::Boolean(*b, None)
                                        }
                                        _ => {
                                            return Err("不支持的值类型".to_string());
                                        }
                                    };
                                    func_args
                                        .push(crate::ast::Argument::Positional(value_node, None));
                                } else if params.len() == 1 {
                                    // 如果只有一个参数，只传递值
                                    // 根据值的类型创建相应的ASTNode
                                    let value_node = match &value.data {
                                        crate::interpreter::value::ValueData::Number(n) => {
                                            if *n == n.floor() {
                                                crate::ast::ASTNode::Integer(*n as i64, None)
                                            } else {
                                                crate::ast::ASTNode::Float(*n, None)
                                            }
                                        }
                                        crate::interpreter::value::ValueData::String(s) => {
                                            crate::ast::ASTNode::String(s.clone(), None)
                                        }
                                        crate::interpreter::value::ValueData::Boolean(b) => {
                                            crate::ast::ASTNode::Boolean(*b, None)
                                        }
                                        _ => {
                                            return Err("不支持的值类型".to_string());
                                        }
                                    };
                                    func_args
                                        .push(crate::ast::Argument::Positional(value_node, None));
                                }

                                // 调用函数
                                // 创建函数调用的参数
                                let _call_args = if params.len() >= 2 {
                                    vec![value.clone()]
                                } else {
                                    vec![]
                                };

                                // 直接调用函数，不通过函数表
                                match &func_value.data {
                                    ValueData::Function {
                                        params: _,
                                        body: _,
                                        closure: _,
                                        return_type: _,
                                    } => {
                                        // 创建新的解释器实例来执行函数
                                        let mut func_interpreter =
                                            crate::interpreter::interpreter::Interpreter::new();

                                        // 创建参数列表
                                        let mut final_args = Vec::new();

                                        if params.len() >= 2 {
                                            // 添加键作为第一个参数
                                            final_args.push(Value::string(key.clone()));
                                            // 添加值作为第二个参数
                                            final_args.push(value.clone());
                                        } else if params.len() == 1 {
                                            // 只添加值作为参数
                                            final_args.push(value.clone());
                                        }

                                        // 调用函数
                                        match func_interpreter
                                            .execute_function_value(func_value, &final_args)
                                        {
                                            Ok(result) => {
                                                new_items.insert(key.clone(), result);
                                            }
                                            Err(_) => {
                                                return Err("映射值函数执行失败".to_string());
                                            }
                                        }
                                    }
                                    _ => {
                                        return Err("映射值需要一个函数".to_string());
                                    }
                                }
                            }

                            Ok(Value::dict(new_items))
                        }
                        _ => Err("映射值需要一个函数".to_string()),
                    }
                } else {
                    Err("映射值方法参数错误".to_string())
                }
            }),
        );

        methods.insert(
            "筛选".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), func_value) = (&args[0].data, &args[1]) {
                    match &func_value.data {
                        ValueData::Function {
                            params,
                            body: _,
                            closure: _,
                            return_type: _,
                        } => {
                            let mut new_items = std::collections::HashMap::new();
                            let items = items.borrow();

                            for (key, value) in items.iter() {
                                // 创建函数调用参数
                                let mut func_args = Vec::new();

                                if params.len() >= 2 {
                                    // 如果有两个参数，键和值都传递
                                    func_args.push(crate::ast::Argument::Positional(
                                        crate::ast::ASTNode::String(key.clone(), None),
                                        None,
                                    ));
                                    // 根据值的类型创建相应的ASTNode
                                    let value_node = match &value.data {
                                        crate::interpreter::value::ValueData::Number(n) => {
                                            if *n == n.floor() {
                                                crate::ast::ASTNode::Integer(*n as i64, None)
                                            } else {
                                                crate::ast::ASTNode::Float(*n, None)
                                            }
                                        }
                                        crate::interpreter::value::ValueData::String(s) => {
                                            crate::ast::ASTNode::String(s.clone(), None)
                                        }
                                        crate::interpreter::value::ValueData::Boolean(b) => {
                                            crate::ast::ASTNode::Boolean(*b, None)
                                        }
                                        _ => {
                                            return Err("不支持的值类型".to_string());
                                        }
                                    };
                                    func_args
                                        .push(crate::ast::Argument::Positional(value_node, None));
                                } else if params.len() == 1 {
                                    // 如果只有一个参数，只传递值
                                    // 根据值的类型创建相应的ASTNode
                                    let value_node = match &value.data {
                                        crate::interpreter::value::ValueData::Number(n) => {
                                            if *n == n.floor() {
                                                crate::ast::ASTNode::Integer(*n as i64, None)
                                            } else {
                                                crate::ast::ASTNode::Float(*n, None)
                                            }
                                        }
                                        crate::interpreter::value::ValueData::String(s) => {
                                            crate::ast::ASTNode::String(s.clone(), None)
                                        }
                                        crate::interpreter::value::ValueData::Boolean(b) => {
                                            crate::ast::ASTNode::Boolean(*b, None)
                                        }
                                        _ => {
                                            return Err("不支持的值类型".to_string());
                                        }
                                    };
                                    func_args
                                        .push(crate::ast::Argument::Positional(value_node, None));
                                }

                                // 调用函数
                                match &func_value.data {
                                    ValueData::Function {
                                        params: _,
                                        body: _,
                                        closure: _,
                                        return_type: _,
                                    } => {
                                        // 创建新的解释器实例来执行函数
                                        let mut func_interpreter =
                                            crate::interpreter::interpreter::Interpreter::new();

                                        // 创建参数列表
                                        let mut final_args = Vec::new();

                                        if params.len() >= 2 {
                                            // 添加键作为第一个参数
                                            final_args.push(Value::string(key.clone()));
                                            // 添加值作为第二个参数
                                            final_args.push(value.clone());
                                        } else if params.len() == 1 {
                                            // 只添加值作为参数
                                            final_args.push(value.clone());
                                        }

                                        // 调用函数
                                        match func_interpreter
                                            .execute_function_value(func_value, &final_args)
                                        {
                                            Ok(result) => {
                                                if let ValueData::Boolean(true) = &result.data {
                                                    new_items.insert(key.clone(), value.clone());
                                                }
                                            }
                                            Err(_) => {
                                                return Err("筛选函数执行失败".to_string());
                                            }
                                        }
                                    }
                                    _ => {
                                        return Err("筛选需要一个函数".to_string());
                                    }
                                }
                            }

                            Ok(Value::dict(new_items))
                        }
                        _ => Err("筛选需要一个函数".to_string()),
                    }
                } else {
                    Err("筛选方法参数错误".to_string())
                }
            }),
        );

        methods.insert(
            "遍历".to_string(),
            Method::native(MethodType::Dict, |args| {
                if let (ValueData::Dict(items), func_value) = (&args[0].data, &args[1]) {
                    match &func_value.data {
                        ValueData::Function {
                            params,
                            body: _,
                            closure: _,
                            return_type: _,
                        } => {
                            let items = items.borrow();

                            for (key, value) in items.iter() {
                                // 创建函数调用参数
                                let mut func_args = Vec::new();

                                if params.len() >= 2 {
                                    // 如果有两个参数，键和值都传递
                                    func_args.push(crate::ast::Argument::Positional(
                                        crate::ast::ASTNode::String(key.clone(), None),
                                        None,
                                    ));
                                    // 根据值的类型创建相应的ASTNode
                                    let value_node = match &value.data {
                                        crate::interpreter::value::ValueData::Number(n) => {
                                            if *n == n.floor() {
                                                crate::ast::ASTNode::Integer(*n as i64, None)
                                            } else {
                                                crate::ast::ASTNode::Float(*n, None)
                                            }
                                        }
                                        crate::interpreter::value::ValueData::String(s) => {
                                            crate::ast::ASTNode::String(s.clone(), None)
                                        }
                                        crate::interpreter::value::ValueData::Boolean(b) => {
                                            crate::ast::ASTNode::Boolean(*b, None)
                                        }
                                        _ => {
                                            return Err("不支持的值类型".to_string());
                                        }
                                    };
                                    func_args
                                        .push(crate::ast::Argument::Positional(value_node, None));
                                } else if params.len() == 1 {
                                    // 如果只有一个参数，只传递值
                                    // 根据值的类型创建相应的ASTNode
                                    let value_node = match &value.data {
                                        crate::interpreter::value::ValueData::Number(n) => {
                                            if *n == n.floor() {
                                                crate::ast::ASTNode::Integer(*n as i64, None)
                                            } else {
                                                crate::ast::ASTNode::Float(*n, None)
                                            }
                                        }
                                        crate::interpreter::value::ValueData::String(s) => {
                                            crate::ast::ASTNode::String(s.clone(), None)
                                        }
                                        crate::interpreter::value::ValueData::Boolean(b) => {
                                            crate::ast::ASTNode::Boolean(*b, None)
                                        }
                                        _ => {
                                            return Err("不支持的值类型".to_string());
                                        }
                                    };
                                    func_args
                                        .push(crate::ast::Argument::Positional(value_node, None));
                                }

                                // 调用函数，忽略结果
                                // 将函数值作为参数传递，而不是存储在functions表中

                                // 直接调用函数，不通过函数表
                                match &func_value.data {
                                    ValueData::Function {
                                        params: _,
                                        body: _,
                                        closure: _,
                                        return_type: _,
                                    } => {
                                        // 创建新的解释器实例来执行函数
                                        let mut func_interpreter =
                                            crate::interpreter::interpreter::Interpreter::new();

                                        // 创建参数列表
                                        let mut final_args = Vec::new();

                                        if params.len() >= 2 {
                                            // 添加键作为第一个参数
                                            final_args.push(Value::string(key.clone()));
                                            // 添加值作为第二个参数
                                            final_args.push(value.clone());
                                        } else if params.len() == 1 {
                                            // 只添加值作为参数
                                            final_args.push(value.clone());
                                        }

                                        // 调用函数，忽略结果
                                        if let Err(_) = func_interpreter
                                            .execute_function_value(func_value, &final_args)
                                        {
                                            return Err("遍历函数执行失败".to_string());
                                        }
                                    }
                                    _ => {
                                        return Err("遍历需要一个函数".to_string());
                                    }
                                }
                            }

                            Ok(Value::null())
                        }
                        _ => Err("遍历需要一个函数".to_string()),
                    }
                } else {
                    Err("遍历方法参数错误".to_string())
                }
            }),
        );

        // 添加通用方法
        super::super::value::Value::add_common_methods(&mut methods, "辞");

        Value {
            type_name: "辞".to_string(),
            data: ValueData::Dict(Rc::new(RefCell::new(items))),
            methods: Rc::new(RefCell::new(methods)),
        }
    }

    /// 将Value转换为字典键
    fn value_to_key(value: &Value) -> Result<String, String> {
        match &value.data {
            ValueData::Number(n) => {
                if *n == n.floor() {
                    Ok(format!("{}", *n as i64))
                } else {
                    Ok(format!("{}", n))
                }
            }
            ValueData::String(s) => Ok(s.clone()),
            ValueData::Boolean(b) => Ok(if *b { "真" } else { "伪" }.to_string()),
            _ => Err(format!("不支持的键类型: {}", value.get_type_name())),
        }
    }
}
